$ sudo apt-get install php5-common libapache2-mod-php5 php5-cli

$ curl -s http://php-osx.liip.ch/install.sh | bash -s 7.0

$ curl -s http://php-osx.liip.ch/install.sh | bash -s 5.6

// so, this is a PHP variable
$a = 5;

// compare value; return true
var_dump($a == 5);

// compare value (ignore type); return true
var_dump($a == '5');

// compare type/value (integer vs. integer); return true
var_dump($a === 5);

// compare type/value (integer vs. string); return false
var_dump($a === '5');

$a++; // or: ++$a;

$b--; // or: --$b;

$a && $b;   // AND
$a || $b;   // OR

! $a;       // `true` if $a is not `true`

$a . 'foo'; // concatenation

2 ** 3 = 8 // exponentiation (PHP 5.6+)

$a  = 'foo';
$a .= 'bar';
// $a => 'foobar'

$b  = 0;
$b += 1;    // $b = 1
$b -= 1;    // $b = 0

$c = 2;
$c **= 3;   // $c = 8

// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';

// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

class Foo
{
}

abstract class AbstractFoo
{
    abstract public function doSomething();
}

$foo = new Foo();
// $foo = new Foo;

// can also be done with a variable
$class = 'Foo';
$foo   = new $class();

echo get_class($foo);
=> Foo

if ($foo instanceof Foo) {
    // do something
}

new class {
    public function foo() {
        return 'foo';
    }
}

interface Logger {
    public function log($msg);
}

$logger = new class implements Logger {
    public function log($msg) {
        // ...
    }
};

$logger->log('Hello, Anonymous Class');

class Foo
{
    const VALUE = 123;
    // PHP 5.6+
    const SENTENCE        = 'The value of VALUE is ' . self::VALUE;
    const ARRAY_OF_VALUES = ['a', 'b'];

    /**
     * @var int
     */
    public static $count = 0;

    /**
     * @var Iterator
     */
    public $iterator;

    /**
     * @var array
     */
    protected $values = array();

    /**
     * @var string|null
     */
    private $language = null;
}

class Foo
{
    public function doSomething()
    {
    }
}

public function doSomething(Foo $foo);

public function doSomething(Traversable $iterator);

public function doSomething(array $values);

public function doSomething(callable $callback);

public function doSomething(Closure $closure);

function sumOfInts(int ...$ints) {
    return array_sum($ints);
}

function sumOfInts(int ...$ints) : int {
    return array_sum($ints);
}

$foo = new Foo();
$foo->doSomething();

// >= PHP 5.4
(new Foo())->doSomething();

// can also be done with a variable
$method = 'doSomething';
$foo->$method();

$foo->{$method . 'Else'}();
// will call 'doSomethingElse()'; curly braces are required.

public function doSomething()
{
    // method call
    $this->doSomethingElse();

    // parent method call (inheritance)
    parent::doSomething();

    // accessing a constant
    self::VALUE;

    // accessing a constant from another class
    Bar::ANOTHER_VALUE;

    // accessing an attribute
    return $this->attribute;
}

class Foo
{
    public static $value;

    public static function doThings()
    {
        // accessing a static attribute
        // don't forget the dollar sign!
        self::$value;
    }
}

class A
{
    public static function who() { echo __CLASS__; }

    public static function testSelf()
    {
        self::who();
    }

    public static function testStatic()
    {
        static::who();
    }
}

class B extends A
{
    public static function who() { echo __CLASS__; }
}

B::testSelf();
// A

B::testStatic();
// B

$foo = new Foo();

// accessing the attribute from an instance
$foo::$value = 123;

// accessing the attribute directly from the class
echo Foo::$value;
=> 123

function sum(...$numbers)
{
    return array_sum($numbers);
}

echo sum(1, 2);
// 3

$numbers = [ 2, 3 ];
echo sum(1, ...$numbers);
// 6

interface Fooable
{
    const VALUE = 123;

    // it's always public anyway
    public function doSomething();
}

// Interface may extend several other interfaces.
// This is not possible with class though!
interface MyTraversable extends Traversable, Countable
{
}

// a class may implement several interfaces, but may extend only one class!
class Foo implements Fooable, MyTraversable {}

namespace Vendor\Model;
// ...

namespace MyNamespace {
    // ...
}

\ns\package\Class_Name      => vendor/ns/package/Class/Name.php
\ns\package_name\Class_Name => vendor/ns/package_name/Class/Name.php

namespace My\Namespace;

// Pre PHP 7 code
use some\namespace\ClassA;
use some\namespace\ClassB;

use function some\namespace\fn_a;
use function some\namespace\fn_b;

// PHP 7+ code
use some\namespace\{ClassA, ClassB};

use function some\namespace\{fn_a, fn_b};

class MyClass
{
    public function __construct(ClassA $a, ClassB $b) {
        // ...
    }
}

namespace My\Namespace;

class ClassName
{
}

echo ClassName::class;
// My\namespace\ClassName

trait Hello                         trait World
{                                   {
    public function sayHello()          public function sayWorld()
    {                                    {
        echo 'Hello ';                       echo 'World';
    }                                    }
}                                   }

class MyHelloWorld
{
    use Hello, World;
}

$obj = new MyHelloWorld();
$obj->sayHello();
$obj->sayWorld();

$greet = function ($name) {
    printf("Hello %s\n", $name);
};

$greet('World');
=> Hello World

$fibonacci = function ($n) use (&$fibonacci) {
    if (0 === $n || 1 === $n) {
        return $n;
    }

    return $fibonacci($n - 1) + $fibonacci($n - 2);
};

echo (int) $fibonacci(6);
=> 8

__construct() { /* ... */ }

__toString() { /* ... */ }

$ php -r 'echo "Hello, World\n"'
Hello, World

$ php -a
Interactive Shell

php > echo "Hello, World\n";
Hello, World

$ php -l my/script.php
No syntax errors detected in my/script.php

$ php -S localhost:8000

#!/usr/bin/env php
<?php

if (2 !== $argc) {
    echo "Usage: php $argv[0] [name]\n";
    exit(1);
}

$name = $argv[1];
echo "Hello, $name!\n";

$ ./hello.php
Usage: ./hello.php [name]

$ php hello.php
Usage: php hello.php [name]

$ php hello.php World
Hello, World!

GET /my/simple/uri?with-query-string HTTP/1.1
Host: example.org
Content-Type: text/plain; charset=utf-8
Content-Length: 17

This is a content

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 76

<!DOCTYPE HTML>
<html>
    <head>
    </head>
    <body>
        <h1>Hello world !</h1>
    </body>
</html>

GET /my/simple/uri?a=1&id=2 HTTP/1.1
Host: example.org
Content-Type: text/plain; charset=utf-8
Content-Length: 14

b=3&city=paris

$_GET     = [ "a" => 1, "id" => 2 ];

$_POST    = [ "b" => 3, "city" => 'paris' ];

$_REQUEST = [ "a" => 1, "id" => 2, "b" => 3, "city" => 'paris' ];

$_SERVER['QUERY_STRING'] = "a=1&id=2";

$HTTP_RAW_POST_DATA      = "b=3&city=paris";

Accept: application/json, application/xml;q=0.9, text/html;q=0.8,
    text/*;q=0.7, */*;q=0.5

<?xml version="1.0" encoding="UTF-8"?>
<collection page="1" limit="10" pages="1">
    <user id="123"></user>
    <user id="456"></user>

    <link rel="self" href="/api/users?page=1&amp;limit=10" />
    <link rel="first" href="/api/users?page=1&amp;limit=10" />
    <link rel="last" href="/api/users?page=1&amp;limit=10" />
</collection>

class Octopus
{
    public function scream()
    {
        echo "o o O O  ° °";
    }
}

$paul = new Octopus();
$paul->scream();

Fatal error: Class 'Octopus' not found in /path/to/file.php

require __DIR__ . '../Model/Octopus.php';

$paul = new Octopus();
$paul->scream();

// somewhere further in your application
require __DIR__ . '../Model/Octopus.php';

class Squid extends Octopus
{
}

Fatal error: Cannot redeclare class Octopus in /path/to/file.php

require_once __DIR__ . '../Model/Octopus.php';

$paul = new Octopus();
$paul->scream();

// somewhere further in your application
require_once __DIR__ . '../Model/Octopus.php';

class Squid extends Octopus
{
}

<?php

/**
 * lib/Model/Location.php
 */
require_once __DIR__ . '/../../common.php';
require_once DOCROOT . '/lib/Model/ModelRepresentation.php';
require_once DOCROOT . '/lib/Model/User.php';
require_once DOCROOT . '/lib/Validator/Email.php';
require_once DOCROOT . '/lib/Validator/Username.php';
require_once DOCROOT . '/lib/Validator/Url.php';

class Location implements ModelRepresentation
{
    /* ... */
}

function __autoload($className)
{
    require_once __DIR__ . DIRECTORY_SEPARATOR . $className . '.php';
}

function my_autoload($className)
{
    require_once __DIR__ . DIRECTORY_SEPARATOR . $className . '.php';
}

spl_autoload_register('my_autoload');

spl_autoload_unregister('my_autoload');

new Foo();

1. Does the 'Foo' class exist?
    => Yes
        Go on

    => No
         Do you have registered autoload functions?
            => Yes
                Call each function with 'Foo' as parameter
                until the class gets included

            => No
                Is there a `__autoload()` method?
                    => Yes
                        Call `__autoload('Foo')`

2. Does the 'Foo' class exist?
    => Yes
        Continue
    => No
        Fatal Error

\Zend\Mail\Message
// => /path/to/project/lib/vendor/Zend/Mail/Message.php

Zend_Mail_Message
// => /path/to/project/lib/vendor/Zend/Mail/Message.php

$tom = new MyObject();
$tom['name'] = 'Tom';

/** A comment */
class MyClass
{
    public function hello() { printf("Hello %s", $this->getName()); }

    protected function getName() { return 'foo'; }
}

$reflClass = new ReflectionClass('MyClass');

// access comments
var_dump($reflClass->getDocComment());
// string(16) "/** A comment */"

// get all methods
$reflClass->getMethods();

// get all public methods
$reflClass->getMethods(ReflectionMethod::IS_PUBLIC);

class MyClass
{
    public function hello() { printf("Hello %s", $this->getName()); }

    private function getName() { return 'foo'; }
}

$reflClass = new ReflectionClass('MyClass');

// access private method
$method = $reflClass->getMethod('getName');
$method->setAccessible(true);

$method->invoke(new MyClass());
// 'foo'

class Subject implements SplSubject
{
    /* ... */
}

class Observer implements SplObserver
{
    /* ... */
}

$subject = new Subject();

$observer1 = new Observer();

$subject->attach($observer1);

$subject->notify();

use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\Event;

$dispatcher = new EventDispatcher();

$dispatcher->addListener('event_name', function (Event $event) {
    // ...
});

$dispatcher->dispatch('event_name');

try {
    // ...
} catch (RuntimeException $e) {
    // do something
} catch (Exception $e) {
    // do something else
}

class SomethingWentWrong extends RuntimeException
{
}

class ErrorWhileDoingSomething extends Exception implements ExceptionInterface
{
}

try {
    // ..
} catch (Exception $e) {
    // do something
} finally {
    // the code here will always be executed
}

$passwordHash = password_hash('secret-password', PASSWORD_DEFAULT);

if (password_verify('bad-password', $passwordHash)) {
    // Correct Password
} else {
    // Wrong password
}

$ curl -sS https://getcomposer.org/installer | php

{
    "require": {
        "willdurand/geocoder": "~2.0"
    }
}

$ php composer.phar require willdurand/geocoder

$ php composer.phar install

<?php

require 'vendor/autoload.php';

// your PHP code

class PhpTemplateEngine implements TemplateEngine
{
    private $templateDir;

    public function __construct($templateDir)
    {
        $this->templateDir = $templateDir;
    }

    public function render($template, array $parameters = [])
    {
        extract($parameters);

        ob_start();
        include $this->templateDir . DIRECTORY_SEPARATOR . $template;

        return ob_get_clean();
    }
}

<!-- my_template.html -->
<p>Hello, <?php echo $name; ?>!</p>

<p>Hello, <?= $name ?>!</p>

$engine = new PhpTemplateEngine('/path/to/templates');

echo $engine->render('my_template.html', [
    'name' => 'World',
]);
=> <p>Hello, World!</p>

{# my_template.html #}
<p>Hello, {{ name }}!</p>

$loader = new Twig_Loader_Filesystem('/path/to/templates');
$engine = new Twig_Environment($loader, [
    'cache' => '/path/to/compilation_cache',
]);

echo $engine->render('my_template.html', [
    'name' => 'World',
]);
=> <p>Hello, World!</p>

class BananaController
{
    public function __construct(
        BananaRepository $repository,
        TemplateEngine $engine
    ) {
        $this->repository = $repository;
        $this->engine     = $engine;
    }

    public function listAction()
    {
        $bananas = $this->repository->findAll();

        return $this->engine->render('list.html', [
            'bananas' => $bananas,
        ]);
    }
}

web/
├ trees/
│ └ pineapple.php
└ tree.php

// This is the implementation of `BananaGateway`
class Banana
{
    private $id;

    private $name;

    public function getId()
    {
        return $this->id;
    }

    public function getName()
    {
        return $this->name;
    }

    public function setName($name)
    {
        $this->name = $name;
    }
}

$con = new Connection('...');

$banana = new Banana();
$banana->setName('Super Banana');

// Save the banana
$banana->insert($con);

// Update it
$banana->setName('New name for my banana');
$banana->update($con);

// Delete it
$banana->delete($con);

public function insert(Connection $con)
{
    // Prepared statement
    $stmt = $this->con->prepare('INSERT INTO bananas VALUES (:name)');

    $stmt->bindValue(':name', $name);

    $stmt->execute();

    // Set the id for this banana
    //
    // It becomes easy to know whether the banana is new or not,
    // you just need to check if id is defined.
    $this->id = $this->con->lastInsertId();
}

$table = new BananaGateway(new Connection('...'));

// Insert a new record
$id = $table->insert('My favorite banana');

// Update it
$table->update($id, 'THE banana');

// Delete it
$table->delete($id);

class BananaGateway
{
    private $con;

    public function __construct(Connection $con)
    {
        $this->con = $con;
    }

    public function insert($name) {}

    public function update($id, $name) {}

    public function delete($id);
}

/**
 * @param string $name The name of the banana you want to create
 *
 * @return int The id of the banana
 */
public function insert($name)
{
    // Prepared statement
    $stmt = $this->con->prepare('INSERT INTO bananas VALUES (:name)');

    $stmt->bindValue(':name', $name);

    $stmt->execute();

    return $this->con->lastInsertId();
}

/**
 * @param int    $id   The id of the banana to update
 * @param string $name The new name of the banana
 *
 * @return bool Returns `true` on success, `false` otherwise
 */
public function update($id, $name)
{
    $stmt = $this->con->prepare(<<<SQL
UPDATE bananas
SET name = :name
WHERE id = :id
SQL
    );

    $stmt->bindValue(':id', $id);
    $stmt->bindValue(':name', $name);

    return $stmt->execute();
}

/**
 * @param int $id The id of the banana to delete
 *
 * @return bool Returns `true` on success, `false` otherwise
 */
public function delete($id)
{
    $stmt = $this->con->prepare('DELETE FROM bananas WHERE id = :id');

    $stmt->bindValue(':id', $id);

    return $stmt->execute();
}

// Retrieve all bananas
$bananas = $table->findAll();

// Find bananas by name matching 'THE %'
$bananas = $table->findByName('THE %');

// Retrieve a given banana using its id
$banana = $table->find(123);

// Find one banana by name matching 'THE %'
$banana = $table->findOneByName('THE %');

$con = new Connection('...');

$banana = new Banana();
$banana->setName('Another banana');
$banana->save($con);

// Call a method that is part of the domain logic
// What can a banana do anyway?
$banana->grow();

// Smart `save()` method
// use `isNew()` under the hood
$banana->save($con);

class Banana
{
    private $height = 1;

    public function grow()
    {
        $this->height++;
    }

    public function save(Connection $con)
    {
        if ($this->isNew()) {
            // issue an INSERT query
        } else {
            // issue an UPDATE query
        }
    }

    public function isNew()
    {
        // Yoda style
        return null === $this->id;
    }
}

class BananaMapper
{
    private $con;

    public function __construct(Connection $con)
    {
        $this->con = $con;
    }

    public function persist(Banana $banana)
    {
        // code to save the banana
    }

    public function remove(Banana $banana)
    {
        // code to delete the banana
    }
}

$banana = new Banana();
$banana->setName('Fantastic Banana');

$con    = new Connection('...');
$mapper = new BananaMapper($con);

$mapper->persist($banana);

$mapper->remove($banana);

class Finder
{
    private $identityMap = [];

    public function find($id)
    {
        if (!isset($this->identityMap[$id])) {
            // fetch the object for the given id
            $this->identityMap[$id] = ...;
        }

        return $this->identityMap[$id];
    }
}

$dsn = 'mysql:host=localhost;dbname=test';

$con = new PDO($dsn, $user, $password);

// Prepared statement
$stmt = $con->prepare($query);
$stmt->execute();

class Connection extends PDO
{
}

$con = new Connection($dsn, $user, $password);

class Connection extends PDO
{
    /**
     * @param string $query
     * @param array  $parameters
     *
     * @return bool Returns `true` on success, `false` otherwise
     */
    public function executeQuery($query, array $parameters = [])
    {
        $stmt = $this->prepare($query);

        foreach ($parameters as $name => $value) {
            $stmt->bindValue(':' . $name, $value);
        }

        return $stmt->execute();
    }
}

/**
 * @param int    $id   The id of the banana to update
 * @param string $name The new name of the banana
 *
 * @return bool Returns `true` on success, `false` otherwise
 */
public function update($id, $name)
{
    $query = 'UPDATE bananas SET name = :name WHERE id = :id';

    return $this->con->executeQuery($query, [
        'id'    => $id,
        'name'  => $name,
    ]);
}

class Customer
{
    private $id;

    private $name;

    public function __construct($id, Name $name)
    {
        $this->id   = $id;
        $this->name = $name;
    }

    public function getId()
    {
        return $this->id;
    }

    public function getName()
    {
        return $this->name;
    }
}

class Name
{
    private $firstName;

    private $lastName;

    public function __construct($firstName, $lastName)
    {
        $this->firstName = $firstName;
        $this->lastName  = $lastName;
    }

    public function getFirstName()
    {
        return $this->firstName;
    }

    public function getLastName()
    {
        return $this->lastName;
    }
}

interface CustomerRepository
{
    /**
     * @return Customer
     */
    public function find($customerId);

    /**
     * @return Customer[]
     */
    public function findAll();

    public function add(Customer $user);

    public function remove(Customer $user);
}

interface CustomerSpecification
{
    /**
     * @return boolean
     */
    public function isSatisfiedBy(Customer $customer);
}

class CustomerIsPremium implements CustomerSpecification
{
    /**
     * {@inheritDoc}
     */
    public function isSatisfiedBy(Customer $customer)
    {
        // figure out if the customer is indeed premium,
        // and return true or false.
    }
}

interface CustomerRepository
{
    ...

    /**
     * @return Customer[]
     */
    public function findSatisfying(CustomerSpecification $specification);
}

$specification = new CustomerIsPremium();
$customers     = $repository->findSatisfying($specification);

class OrSpecification implements CustomerSpecification
{
    public function __construct(
        CustomerSpecification $s1,
        CustomerSpecification $s2
    ) {
        $this->s1 = $s1;
        $this->s2 = $s2;
    }

    public function isSatisfiedBy(Customer $c)
    {
        return $this->s1->isSatisfiedBy($c) || $this->s2->isSatisfiedBy($c);
    }
}

class AndSpecification implements CustomerSpecification
{
    ...

    public function isSatisfiedBy(Customer $c)
    {
        return $this->s1->isSatisfiedBy($c) && $this->s2->isSatisfiedBy($c);
    }
}

class NotSpecification implements CustomerSpecification
{
    public function __construct(CustomerSpecification $s)
    {
        $this->s = $s;
    }

    public function isSatisfiedBy(Customer $c)
    {
        return !$this->s->isSatisfiedBy($c);
    }
}

// Find customers who have ordered exactly three times,
// but who are not premium customers (yet?)
$specification = new AndSpecification(
    new CustomerHasOrderedThreeTimes(),
    new NotSpecification(
        new CustomerIsPremium()
    )
);

$customers = $repository->findSatisfying($specification);

class AwesomeOfferSender
{
    private $specification;

    public function __construct(CustomerIsPremium $specification)
    {
        $this->specification = $specification;
    }

    public function sendOffersTo(Customer $customer)
    {
        if ($this->specification->isSatisfiedBy($customer)) {
            // send offers
        }
    }
}

// Initalize session
session_start();

// Regenerate identifier
session_regenerate_id();

// Assign "key" to `$value`
$_SESSION['key'] = $value;

// Retrieve "key"
$_SESSION['key'];

// Terminate session
session_destroy();

; Helps mitigate XSS by telling the browser not to expose the cookie to
; client side scripting such as JavaScript
session.cookie_httponly = 1

; Prevents session fixation by making sure that PHP only uses cookies for
; sessions and disallow session ID passing as a GET parameter
session.use_only_cookies = 1

; Better entropy source
; Evades insufficient entropy vulnerabilities
session.entropy_file = "/dev/urandom"
; `session.entropy_length` might help too!

; Smaller exploitation window for XSS/CSRF/Clickjacking...
session.cookie_lifetime = 0

; Ensures session cookies are only sent over secure connections (it requires
; a valid SSL certificate)
; Related to OWASP 2013-A6-Sensitive Data Exposure
session.cookie_secure = 1

trait EventDispatcherTrait
{
    private $events = [];

    public function addListener($name, $callable)
    {
        $this->events[$name][] = $callable;
    }

    public function dispatch($name, array $arguments = [])
    {
        foreach ($this->events[$name] as $callable) {
            call_user_func_array($callable, $arguments);
        }
    }
}

class App
{
    use EventDispatcherTrait;

    ...

    private function process(Request $request, Route $route)
    {
        $this->dispatch('process.before', [ $request ]);

        ...
    }
}

$app->addListener('process.before', function (Request $request) {
    // code to execute
});

$allowed = [
    '/login'     => [ Request::GET, Request::POST ],
    '/locations' => [ Request::GET ],
];

session_start();

if (isset($_SESSION['is_authenticated'])
    && true === $_SESSION['is_authenticated']) {
    return;
}

$app->addListener('process.before', function(Request $req) use ($app) {
    session_start();

    $allowed = [
        '/login' => [ Request::GET, Request::POST ],
    ];

    if (isset($_SESSION['is_authenticated'])
        && true === $_SESSION['is_authenticated']) {
        return;
    }

    foreach ($allowed as $pattern => $methods) {
        if (preg_match(sprintf('#^%s$#', $pattern), $req->getUri())
            && in_array($req->getMethod(), $methods)) {
            return;
        }
    }

    switch ($req->guessBestFormat()) {
        case 'json':
            throw new HttpException(401);
    }

    return $app->redirect('/login');
});

$app->get('/login', function () use ($app) {
    return $app->render('login.php');
});

$app->post('/login', function (Request $request) use ($app) {
    $user = $request->getParameter('user');
    $pass = $request->getParameter('password');

    if ('will' === $user && 'will' === $pass) {
        $_SESSION['is_authenticated'] = true;

        return $app->redirect('/');
    }

    return $app->render('login.php', [ 'user' => $user ]);
});

$app->get('/logout', function (Request $request) use ($app) {
    session_destroy();

    return $app->redirect('/');
});

BrowserKit              EventDispatcher     OptionsResolver     Templating
ClassLoader             ExpressionLanguage  Process             Translation
Config                  Filesystem          PropertyAccess      VarDumper
Console                 Finder              PropertyInfo        Yaml
CssSelector             Form                Routing
Debug                   HttpFoundation      Security
DependencyInjection     HttpKernel          Serializer
DomCrawler              Intl                Stopwatch

{
    "require": {
        "symfony/yaml": "~3.0"
    }
}

require __DIR__ . '/vendor/autoload.php';

use Symfony\Component\Yaml\Yaml;

$yaml = Yaml::parse('/path/to/file.yml');

use Symfony\Component\HttpFoundation\Request;

$request = Request::createFromGlobals();

// the URI being requested (e.g. /about) minus any query parameters
$request->getPathInfo();

// the HTTP verb
$request->getMethod();

// GET variables
$request->query->get('foo');

// POST variables
$request->request->get('bar');

// SERVER variables
$request->server->get('HTTP_HOST');

// retrieve an HTTP request header, with normalized, lowercase keys
$request->headers->get('host');

use Symfony\Component\HttpFoundation\Response;

$response = new Response();

$response->setContent(<<<HTML
<html>
    <body>
        <h1>Hello world!</h1>
    </body>
</html>
HTML
);

$response->setStatusCode(200);

$response->headers->set('Content-Type', 'text/html');

// prints the HTTP headers followed by the content
$response->send();

// index.php
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

$request = Request::createFromGlobals();
$path    = $request->getPathInfo();

if (in_array($path, ['', '/'])) {
    $response = new Response('Welcome to the homepage.');
} elseif ('/hello' === $path) {
    $response = new Response('hello, World!');
} else {
    $response = new Response('Page not found.', 404);
}

$response->send();

# app/config/routing.yml
hello:
    path:  /hello
    defaults: { _controller: AppBundle:Main:hello }

// src/AppBundle/Controller/MainController.php
namespace AppBundle\Controller;

use Symfony\Component\HttpFoundation\Response;

class MainController
{
    public function helloAction()
    {
        return new Response('<h1>Hello, World!</h1>');
    }
}

path/to/project/
    app/
        config/
        Resources/
            views/
    bin/
        console
    src/
        ...
    tests/
        ...
    var/
        cache/
        logs/
        sessions/
    vendor/
        ...
    web/
        app.php
        ...

// app/AppKernel.php
use Symfony\Component\HttpKernel\Kernel;

class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = [
            new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
            // ...
        ];

        if (in_array($this->getEnvironment(), ['dev', 'test'])) {
            $bundles[] = // dev bundle;
        }

        return $bundles;
    }

    // ...
}

# app/config/config.yml
imports:
    - { resource: parameters.yml }
    - { resource: security.yml }

framework:
    secret: '%secret%'
    router: { resource: '%kernel.root_dir%/config/routing.yml' }
    # ...

# Twig Configuration
twig:
    debug:            '%kernel.debug%'
    strict_variables: '%kernel.debug%'

# ...

<!-- app/config/config.xml -->
<imports>
    <import resource="parameters.yml"/>
    <import resource="security.yml"/>
</imports>

<framework:config secret="%secret%">
    <framework:router resource="%kernel.root_dir%/config/routing.xml"/>
    <!-- ... -->
</framework:config>

<!-- Twig Configuration -->
<twig:config debug="%kernel.debug%" strict-variables="%kernel.debug%"/>

<!-- ... -->

$this->import('parameters.yml');
$this->import('security.yml');

$container->loadFromExtension('framework', [
    'secret' => '%secret%',
    'router' => [
        'resource' => '%kernel.root_dir%/config/routing.php'
    ],
    // ...
]);

// Twig Configuration
$container->loadFromExtension('twig', [
    'debug'            => '%kernel.debug%',
    'strict_variables' => '%kernel.debug%',
]);

// ...

# app/config/config.yml
# ...
twig:
    debug:            '%kernel.debug%'
    strict_variables: '%kernel.debug%'

# app/config/routing.yml
hello:
    path:  /hello
    defaults: { _controller: AppBundle:Main:hello }

<services>
    <service id="acme_demo.controllers.main"
        class="AppBundle\MainController" />
</services>

// web/app.php

// ...
$kernel = new AppKernel('prod', false);

// app/AppKernel.php
public function registerContainerConfiguration(LoaderInterface $loader)
{
    $loader->load(
        __DIR__ . '/config/config_' . $this->getEnvironment() . '.yml'
    );
}

public function registerBundles()
{
    $bundles = array(
        // ...

        new My\AwesomeBundle\MyAwesomeBundle(),
    );

    // ...
}

XXX/...
    DemoBundle/
        DemoBundle.php
        Controller/
        Resources/
            config/
            doc/
                index.rst
            translations/
            views/
            public/
        Tests/
        LICENSE

// src/Acme/MyFirstBundle/AcmeMyFirstBundle.php
namespace Acme\MyFirstBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class AcmeMyFirstBundle extends Bundle
{
}

// app/AppKernel.php
public function registerBundles()
{
    $bundles = array(
        new Acme\MyFirstBundle\AcmeMyFirstBundle(),
    );

    return $bundles;
}

// web/app.php
require_once __DIR__.'/../app/bootstrap.php.cache';
require_once __DIR__.'/../app/AppKernel.php';

use Symfony\Component\HttpFoundation\Request;

$kernel   = new AppKernel('prod', false);
$request  = Request::createFromGlobals();
$response = $kernel->handle($request);
$response->send();

# app/config/routing.yml
homepage:
    path:  /
    defaults: { _controller: AppBundle:Hello:index }

// src/AppBundle/Controller/HelloController.php
namespace AppBundle\Controller;

use Symfony\Component\HttpFoundation\Response;

class HelloController
{
    public function indexAction()
    {
        return new Response('Home, Sweet Home!');
    }
}

# src/AppBundle/Resources/config/routing.yml
app.hello_hello:
    path:  /hello/{name}
    defaults: { _controller: AppBundle:Hello:hello }
    requirements:
        _method: GET

// src/AppBundle/Controller/HelloController.php

class HelloController
{
    // ...

    public function helloAction($name)
    {
        return new Response(sprintf('Home, Sweet %s!', $name));
    }
}

use Symfony\Component\HttpFoundation\Request;

class HelloController
{
    // ...

    public function updateAction(Request $request)
    {
        // do something useful with $request
    }
}

use Symfony\Bundle\FrameworkBundle\Controller\Controller

class HelloController extends Controller
{
    // ...
}

$this->redirect($this->generateUrl('homepage'));

return $this->render(
    'hello/hello.html.twig', array('name' => $name)
);

use Symfony\Component\HttpFoundation\Response;

$response = new Response('Hello, ' . $name, 200);

$response = new Response(json_encode(array('name' => $name)));
$response->headers->set('Content-Type', 'application/json');

use Symfony\Component\HttpFoundation\JsonResponse;

$response = new JsonResponse(array('name' => $name));

# app/config/routing.yml
homepage:
    path:  /
    defaults: { _controller: AppBundle:Hello:index }

blog:
    path:      /blog/{page}
    defaults:  { _controller: AcmeBlogBundle:Blog:index }

blog:
    path:      /blog/{page}
    defaults:  { _controller: AcmeBlogBundle:Blog:index, page: 1 }